// package com.cxy;
//
// import com.hundsun.tbsp.commbiz.enums.ErrorEnum;
// import com.hundsun.tbsp.common.common.enums.IEnum;
// import com.hundsun.tbsp.fsds.base.enums.FsdsBizErrorEnum;
// import com.hundsun.tbsp.fsds.base.enums.FsdsBizTrcodeEnum;
// import com.hundsun.tbsp.fsds.dao.entity.IftsBizErrorExchange;
// import com.hundsun.tbsp.fsds.dao.inter.IftsBizErrorExchangeMapper;
// import org.apache.commons.collections.CollectionUtils;
// import org.springframework.beans.factory.annotation.Autowired;
// import org.springframework.stereotype.Component;
// import org.springframework.stereotype.Controller;
// import org.springframework.web.bind.annotation.RequestMapping;
// import org.springframework.web.bind.annotation.ResponseBody;
// import spoon.Launcher;
// import spoon.reflect.code.CtAbstractInvocation;
// import spoon.reflect.code.CtExpression;
// import spoon.reflect.code.CtIf;
// import spoon.reflect.code.CtInvocation;
// import spoon.reflect.declaration.CtClass;
// import spoon.reflect.declaration.CtMethod;
// import spoon.reflect.declaration.CtType;
// import spoon.reflect.reference.CtExecutableReference;
// import spoon.reflect.reference.CtTypeReference;
// import spoon.reflect.visitor.filter.AbstractFilter;
// import spoon.reflect.visitor.filter.LineFilter;
// import spoon.reflect.visitor.filter.TypeFilter;
// import spoon.support.reflect.code.CtBinaryOperatorImpl;
// import spoon.support.reflect.code.CtConstructorCallImpl;
// import spoon.support.reflect.code.CtIfImpl;
// import spoon.support.reflect.code.CtInvocationImpl;
//
// import java.io.File;
// import java.io.FileOutputStream;
// import java.io.IOException;
// import java.nio.charset.StandardCharsets;
// import java.util.ArrayList;
// import java.util.Arrays;
// import java.util.HashMap;
// import java.util.HashSet;
// import java.util.List;
// import java.util.Map;
// import java.util.Set;
// import java.util.stream.Collectors;
//
// /**
//  * 		<dependency>
//  * 			<groupId>fr.inria.gforge.spoon</groupId>
//  * 			<artifactId>spoon-core</artifactId>
//  * 			<version>9.1.0</version>
//  * 		</dependency>
//  */
// @Component
// @Controller
// public class Test2 {
//
//
//     @Autowired
//     private IftsBizErrorExchangeMapper iftsBizErrorExchangeMapper;
//     @RequestMapping("getdd")
//     @ResponseBody
//     void dd(){
//         File file = new File("./错误码转换.txt");
//         try {
//             FileOutputStream fileOutputStream = new FileOutputStream(file);
//
//             List<TestMetedata> start = Test2.start();
//             Set<String> stringsOther = new HashSet<>();
//             // SELECT '000','PTCG','iftsStandard','3','P','P','中断','1',sysdate, sysdate
//             start.forEach(testMetedata -> {
//                 String strings = testMetedata.toString();
//                 for (String string : strings.split("\n")) {
//                     String[] split = string.split("\\|");
//                     if (split.length>3){
//                         IftsBizErrorExchange iftsBizErrorExchange = iftsBizErrorExchangeMapper.selectByPrimaryKey("iftsStandard", "PTCG", "3", split[2], "000");
//                         if (iftsBizErrorExchange != null){
//                             string += "|" + iftsBizErrorExchange.getNewRespCode() + "|" + iftsBizErrorExchange.getNewRespMsg() + "|" + iftsBizErrorExchange.getInterruptFlag();
//                         }else{
//                             stringsOther.add(split[2] + "|" + split[3]);
//                         }
//                     }
//                     try {
//                         fileOutputStream.write((string + "\n").getBytes(StandardCharsets.UTF_8));
//                     } catch (IOException e) {
//                     }
//                 }
//
//
//             });
//             fileOutputStream.write(("************缺失配置**************" + "\n").getBytes(StandardCharsets.UTF_8));
//             stringsOther.forEach(s -> {
//                 try {
//                     fileOutputStream.write((s + "\n").getBytes(StandardCharsets.UTF_8));
//                 } catch (IOException e) {
//
//                 }
//             });
//             fileOutputStream.flush();
//         } catch (Exception e) {
//             throw new RuntimeException(e);
//         }
//
//     }
//     public static List<TestMetedata> start() {
//         String filePath =
//                 "E:\\myIdeawork\\iftsfacade\\src\\main\\java\\com\\hundsun\\ifts\\system\\CtlRole.java"; // 替换为你的 Java 文件路径
//         // filePath = "E:\\myIdeawork\\iftsfacade\\src\\main\\java\\com\\hundsun\\ifts\\app\\batch\\Ctl20002.java";
//         // filePath = "E:\\myIdeawork\\iftsfacade\\src\\main\\java\\com\\hundsun\\ifts\\app\\batch\\Ctl20061.java";
//         filePath = "E:\\Ideawork\\tbsp\\ifts\\fsds-service-impl\\fsds-ptcg-service-impl";
//         Launcher launcher = new Launcher();
//
//         launcher.addInputResource("E:\\Ideawork\\tbsp\\ifts\\fsds-base-component");
//         launcher.addInputResource("E:\\Ideawork\\tbsp\\ifts\\fsds-base-common");
//
//         launcher.addInputResource(filePath);
//         launcher.buildModel();
//
//         ArrayList<TestMetedata> lists = new ArrayList<>();
//         for (CtType<?> ctClass : launcher.getFactory().Class().getAll()) {
// /*            Set<String> methodCalls = new HashSet<>();
//             ctClass.getMethods().forEach(a->scanMethod(a, methodCalls));
//             ;
//
//             System.out.println("Method Chain:");
//             for (String methodCall : methodCalls) {
//                 System.out.println(methodCall);
//             }*/
//             Set<String> parameterMethodInvocations = new HashSet<>();
//             String parameterMethodInvocations1 = findParameterMethodInvocations(launcher, ctClass, parameterMethodInvocations, new HashSet<Object>());
//             if (parameterMethodInvocations1 != null){
//                 TestMetedata testMetedata =
//                         new TestMetedata(parameterMethodInvocations1, parameterMethodInvocations, null);
//                 lists.add(testMetedata);
//             }
//         }
//
//         return lists.stream().sorted().collect(Collectors.toList());
//     }
//
//     private static void collectIfStatements(CtClass<?> ctClass, List<ControllerCode> ifStatements) {
//         CtMethod<Object> doControl = ctClass.getMethod("getTrCode");
//         if (doControl == null){
//             return;
//         }
//         doControl.getElements(new TypeFilter<>(CtIf.class)).stream().filter(o1 -> {
//             CtExpression<Boolean> condition1 = o1.getCondition();
//             if (condition1 instanceof CtInvocationImpl){
//                 return extracted((CtInvocationImpl) condition1,"funcId");
//             } else if (condition1 instanceof CtBinaryOperatorImpl) {
//                 List<CtInvocationImpl> allCtInvocationImpl = getAllCtInvocationImpl(condition1);
//                 List<CtInvocationImpl> funcId1 =
//                         allCtInvocationImpl.stream().filter(a -> extracted(a, "funcId")).collect(Collectors.toList());
//                 return !funcId1.isEmpty();
//             }
//             return false;
//         }).forEach(o1->{
//             CtExpression<Boolean> condition1 = o1.getCondition();
//             if (condition1 instanceof CtInvocationImpl){
//                 extracted(ifStatements, (CtIfImpl) o1, (CtInvocationImpl) condition1);
//
//             } else if (condition1 instanceof CtBinaryOperatorImpl) {
//                 List<CtInvocationImpl> allCtInvocationImpl = getAllCtInvocationImpl(condition1);
//                 List<CtInvocationImpl> funcId1 =
//                         allCtInvocationImpl.stream().filter(a -> extracted(a, "funcId")).collect(Collectors.toList());
//                 if (funcId1.size()>1){
//                     for (CtInvocationImpl invocation : funcId1) {
//                         extracted(ifStatements, (CtIfImpl) o1, (CtInvocationImpl) invocation);
//                     }
//
//                 }else{
//                     CtInvocationImpl invocation = funcId1.get(0);
//                     List<CtInvocationImpl> trSubCodes =
//                             allCtInvocationImpl.stream().filter(a -> extracted(a, "trSubCode")).collect(Collectors.toList());
//                     if (trSubCodes.isEmpty()){
//                         System.out.println("");
//                     }
//                     CtInvocationImpl invocation1 = trSubCodes.get(0);
//                     String funcId = getExtracted(invocation, "funcId");
//                     String trSubCode = getExtracted(invocation1, "trSubCode");
//                     ifStatements.add(new ControllerCode(funcId,trSubCode));
//                 }
//
//             }
//         });
//
//     }
//
//     private static void extracted(List<ControllerCode> ifStatements, CtIfImpl o1, CtInvocationImpl condition1) {
//         CtInvocationImpl invocation = condition1;
//         List<CtIf> elements = o1.getThenStatement().getElements(new TypeFilter<>(CtIf.class));
//         ArrayList<CtInvocationImpl> ctInvocations = new ArrayList<>();
//         elements.forEach(oo->{
//             ctInvocations.addAll(getAllCtInvocationImpl(oo.getCondition()));
//         });
//         ctInvocations.stream().filter(a -> {
//             return extracted((CtInvocationImpl) a, "trSubCode");
//         }).collect(Collectors.toList()).forEach(invocation1 ->{
//             String funcId = getExtracted(invocation, "funcId");
//             String trSubCode = getExtracted(invocation1, "trSubCode");
//             ifStatements.add(new ControllerCode(funcId,trSubCode));
//         });
//     }
//
//     private static List<CtInvocationImpl> getAllCtInvocationImpl(CtExpression condition) {
//         if (condition instanceof CtInvocationImpl){
//             CtInvocationImpl invocation = (CtInvocationImpl)condition;
//             return Arrays.asList(invocation);
//         } else if (condition instanceof CtBinaryOperatorImpl) {
//             CtBinaryOperatorImpl invocation = (CtBinaryOperatorImpl)condition;
//             ArrayList<CtInvocationImpl> list1 = new ArrayList<>();
//             list1.addAll(getAllCtInvocationImpl(invocation.getLeftHandOperand()));
//             list1.addAll(getAllCtInvocationImpl(invocation.getRightHandOperand()));
//             return list1;
//         }
//         return new ArrayList<>();
//     }
//
//     private static boolean extracted(CtInvocationImpl condition1,String str) {
//         CtInvocationImpl condition = condition1;
//         ArrayList<String> strings = new ArrayList<>();
//         condition.getArguments().forEach(o2 -> strings.add(o2.toString()));
//         strings.add(condition.getTarget().toString());
//         return strings.contains(str);
//     }
//     private static String getExtracted(CtInvocationImpl condition1,String str) {
//         CtInvocationImpl condition = condition1;
//         ArrayList<String> strings = new ArrayList<>();
//         condition.getArguments().forEach(o2 -> strings.add(o2.toString()));
//         String s = condition.getTarget().toString();
//         if (s.equals(str)){
//             return strings.get(0).toString();
//         }else{
//             return s;
//         }
//     }
//     private static String findParameterMethodInvocations(Launcher launcher, CtType<?> ctClass,
//                                                     Set<String> parameterMethodInvocations, HashSet<Object> objects) {
// /*        ctClass.getElements(new AbstractFilter<CtInvocation<?>>(CtInvocation.class) {
//             @Override
//             public boolean matches(CtInvocation<?> element) {
//                 CtExecutableReference<?> executable = element.getExecutable();
//                 return executable != null && (
//                         executable.getSimpleName().indexOf("createTbspBaseException") != -1
//                                 || executable.getSimpleName().indexOf("TbspBaseRuntimeException") != -1);
//             }
//         }).stream().map(o1->o1.getArguments().get(0).toString()).forEach(parameterMethodInvocations::add);*/
//         List<CtMethod<?>> getTrCode = ctClass.getMethodsByName("getTrCode");
//         if (CollectionUtils.isNotEmpty(getTrCode) && CollectionUtils.isNotEmpty(getTrCode.get(0).getElements(new LineFilter()))){
//             Set<CtMethod<?>> methods = ctClass.getMethods();
//             methods.forEach(method->{
//                 findParameterMethodInvocations(launcher, method, parameterMethodInvocations,objects);
//             });
//             return getTrCode.get(0).getElements(new LineFilter()).get(0).toString();
//         }
//         return null;
//     }
//
//     private static void findParameterMethodInvocations(Launcher launcher,CtMethod ctClass, Set<String> parameterMethodInvocations, HashSet<Object> objects) {
//         if (!objects.add(ctClass) || ctClass == null){
//             return;
//         }
//         ctClass.getElements(new AbstractFilter<CtInvocation<?>>(CtInvocation.class) {
//             @Override
//             public boolean matches(CtInvocation<?> element) {
//                 CtExecutableReference<?> executable = element.getExecutable();
//                 return executable != null && (
//                         executable.getSimpleName().indexOf("createTbspBaseException") != -1
//                                 );
//             }
//         }).stream().map(o1->o1.getArguments().get(0).toString()).forEach(parameterMethodInvocations::add);
//         ctClass.getElements(new AbstractFilter<CtInvocation<?>>(CtInvocation.class) {
//             @Override
//             public boolean matches(CtInvocation<?> element) {
//                 CtConstructorCallImpl parent = element.getParent(CtConstructorCallImpl.class);
//                 return parent != null &&  parent.toString().indexOf("TbspBaseRuntimeException") != -1 && parent.getArguments().size()>0;
//             }
//         }).stream()
//                 .map(o1->o1.getParent(CtConstructorCallImpl.class))
//                 .map(o1->o1.getArguments().get(0).toString()).forEach(parameterMethodInvocations::add);
//         ctClass.getElements(new AbstractFilter<CtInvocation<?>>(CtInvocation.class){
//             @Override
//             public boolean matches(CtInvocation<?> element) {
//                 return true;
//             }
//         }).forEach(ele->{
//             CtExecutableReference<?> executable = ele.getExecutable();
//             CtTypeReference<?> declaringType = executable.getDeclaringType();
//             if (declaringType == null){
//                 return;
//             }
//             String className = declaringType.getPackage() + "." + declaringType.getSimpleName();
//             String methodName = executable.getSimpleName();
//             CtClass<Object> objectCtClass = launcher.getFactory().Class().get(className);
//             if (objectCtClass !=null && methodName != null && executable.getParameters()!= null){
//                 try {
//                     CtMethod<?> method = objectCtClass.getMethodsByName(methodName).stream()
//                             .filter(meEle -> meEle.getParameters().size() == executable.getParameters().size())
//                             .filter(meEle -> {
//                                 for (int i = 0; i < meEle.getParameters().size(); i++) {
//                                     boolean equals = meEle.getParameters().get(i).getType().getSimpleName().equals(executable.getParameters().get(i).getTypeErasure().getSimpleName());
//                                     if (!equals) {
//                                         return false;
//                                     }
//                                 }
//                                 return true;
//                             }).findFirst().orElse(null);
//                     // CtMethod<Object> method = objectCtClass.getMethod(methodName, executable.getParameters().toArray(new CtTypeReference<?>[0]));
//                     findParameterMethodInvocations(launcher, method, parameterMethodInvocations,objects);
//                 }catch (Exception e){
//                     e.printStackTrace();
//                 }
//             }
//
//         });
//     }
//     public static void scanMethodChain(String className, String methodName) {
//         // Launcher launcher = new Launcher();
//         // launcher.addInputResource(className);
//         //
//         // launcher.buildModel();
//         // CtModel model = launcher.getModel();
//         //
//         // CtClass<?> targetClass = model.getType(className);
//         // CtMethod<?> targetMethod = findMethod(targetClass, methodName);
//         // Set<String> methodCalls = new HashSet<>();
//         // scanMethod(targetMethod, methodCalls);
//         //
//         // System.out.println("Method Chain:");
//         // for (String methodCall : methodCalls) {
//         //     System.out.println(methodCall);
//         // }
//     }
//
//     private static CtMethod<?> findMethod(CtClass<?> ctClass, String methodName) {
//         return ctClass.getMethodsByName(methodName).stream()
//                 .findFirst()
//                 .orElse(null);
//     }
//
//     private static void scanMethod(CtMethod<?> method, Set<String> methodCalls) {
//         if (method == null) {
//             return;
//         }
//
//         System.out.println("Method: " + method.getSimpleName());
//
//         for (CtAbstractInvocation<?> invocation : method.getElements(new TypeFilter<>(CtAbstractInvocation.class))) {
//             String methodCall = method.getSimpleName() + " -> " + invocation.getExecutable().getSimpleName();
//             methodCalls.add(methodCall);
//
//             CtMethod<?> invokedMethod = findMethod((CtClass<?>) invocation.getExecutable().getDeclaringType(), invocation.getExecutable().getSimpleName());
//             scanMethod(invokedMethod, methodCalls);
//         }
//     }
//
//     public static class TestMetedata implements Comparable {
//         static Map<String, IEnum> errorEnumMap=
//                 Arrays.stream(FsdsBizErrorEnum.values()).collect(Collectors.toMap(el->el.name(),el->el));
//         static {
//             errorEnumMap.putAll(Arrays.stream(ErrorEnum.values()).collect(Collectors.toMap(el->el.name(), el->el)));
//             errorEnumMap.putAll(Arrays.stream(com.hundsun.tbsp.common.common.enums.ErrorEnum.values()).collect(Collectors.toMap(el->el.name(), el->el)));
//         }
//         static Map<String, IEnum> trCodseEnumMap=
//                 Arrays.stream(FsdsBizTrcodeEnum.values()).collect(Collectors.toMap(el->el.name(), el->el));
//         static Map<IEnum, Integer> trCodseIndexEnumMap = new HashMap<>();
//
//         static {
//             for (int i = 0; i < FsdsBizTrcodeEnum.values().length; i++) {
//                 try {
//                     trCodseIndexEnumMap.put(FsdsBizTrcodeEnum.values()[i],i);
//                 }catch (Exception e){
//                     e.printStackTrace();
//                 }
//
//             }
//         }
//         String className;
//         Set<String> paramList;
//         List<ControllerCode> controllerCodes;
//
//         IEnum trcode;
//
//         @Override
//         public int compareTo(Object o) {
//             if (trcode != null && trCodseIndexEnumMap.get(((TestMetedata)(o)).trcode) != null){
//                 return trCodseIndexEnumMap.get(trcode) - trCodseIndexEnumMap.get(((TestMetedata)(o)).trcode);
//             }else{
//                 return 0;
//             }
//
//         }
//
//         public TestMetedata(String className, Set<String> paramList, List<ControllerCode> controllerCodes) {
//             if (className.indexOf("TRCODE_") != -1 && className.indexOf(".getCode()")!=-1){
//                 this.trcode = trCodseEnumMap.get(className.substring(className.indexOf("TRCODE_"), className.indexOf(
//                         ".getCode()")));
//                 if (trcode !=null){
//                     this.className = trcode.getCode() + "|" + trcode.getDescription();;
//                 }else{
//                     this.className = className;
//                 }
//             }else{
//                 this.className = className;
//             }
//
//
//             this.paramList = paramList.stream()
//                     .map(code->code.equals("errorCode")?"FsdsBizErrorEnum.FDS2TB320321060002.getCode()":code)
//                     .map(code-> {
//                         IEnum iEnum = errorEnumMap.get(code.replace("FsdsBizErrorEnum.", "")
//                                 .replace("ErrorEnum.", "")
//                                 .replace(".getCode()", ""));
//                         if (iEnum != null){
//                             return iEnum.getCode() + "|" + iEnum.getDescription();
//                         }else{
//                             return code;
//                         }
//                     })
//                     .collect(Collectors.toSet());
//             this.controllerCodes = controllerCodes;
//         }
//
//         @Override
//         public String toString() {
//             return "-------------------\n"
//                     + paramList.stream().sorted().map(str->className + "|" + str).collect(Collectors.joining("\n"));
//         }
//
//
//     }
//     static class ControllerCode {
//         String funId;
//         String subCode;
//
//         public ControllerCode(String funId, String subCode) {
//             this.funId = funId;
//             this.subCode = subCode;
//         }
//
//         @Override
//         public String toString() {
//             return funId + "|" + subCode;
//         }
//     }
// }